package xin.yangshuai.transactional01.service;

public interface PropagationServiceA {

    /**
     * 1：REQUIRED
     * REQUIRED1无异常 + REQUIRED2异常
     */
    void requiredToRequired();

    /**
     * 2：REQUIRED
     * REQUIRED1无异常 + REQUIRED2异常，REQUIRED1捕获REQUIRED2异常
     */
    void requiredToRequired1();

    /**
     * 3：REQUIRED
     * REQUIRED1异常 + REQUIRED2无异常
     */
    void requiredToRequired2();

    /**
     * 4：REQUIRED
     * NO无异常 + REQUIRED异常
     */
    void noToRequired();

    /**
     * 1：SUPPORTS
     * REQUIRED无异常 + SUPPORTS异常
     */
    void requiredToSupports();

    /**
     * 2：SUPPORTS
     * REQUIRED无异常 + SUPPORTS异常，REQUIRED捕获SUPPORTS异常
     */
    void requiredToSupports1();

    /**
     * 3：SUPPORTS
     * REQUIRED异常 + SUPPORTS无异常
     */
    void requiredToSupports2();

    /**
     * 4：SUPPORTS
     * NO无异常 + SUPPORTS异常
     */
    void noToSupports();

    /**
     * 1：MANDATORY
     * REQUIRED无异常 + MANDATORY异常
     */
    void requiredToMandatory();

    /**
     * 2：MANDATORY
     * REQUIRED无异常 + MANDATORY异常，REQUIRED捕获MANDATORY异常
     */
    void requiredToMandatory1();

    /**
     * 3：MANDATORY
     * REQUIRED异常 + MANDATORY无异常
     */
    void requiredToMandatory2();

    /**
     * 4：MANDATORY
     * NO无异常 + MANDATORY异常
     */
    void noToMandatory();

    /**
     * 1：REQUIRES_NEW
     * REQUIRED无异常 + REQUIRES_NEW异常
     */
    void requiredToRequiresNew();

    /**
     * 2：REQUIRES_NEW
     * REQUIRED无异常 + REQUIRES_NEW异常，REQUIRED捕获REQUIRES_NEW异常
     */
    void requiredToRequiresNew1();

    /**
     * 3：REQUIRES_NEW
     * REQUIRED异常 + REQUIRES_NEW无异常
     */
    void requiredToRequiresNew2();

    /**
     * 4：REQUIRES_NEW
     * NO无异常 + REQUIRES_NEW异常
     */
    void noToRequiresNew();

    /**
     * 1：NOT_SUPPORTED
     * REQUIRED无异常 + NOT_SUPPORTED异常
     */
    void requiredToNotSupported();

    /**
     * 2：NOT_SUPPORTED
     * REQUIRED无异常 + NOT_SUPPORTED异常，REQUIRED捕获NOT_SUPPORTED异常
     */
    void requiredToNotSupported1();

    /**
     * 3：NOT_SUPPORTED
     * REQUIRED异常 + NOT_SUPPORTED无异常
     */
    void requiredToNotSupported2();

    /**
     * 4：NOT_SUPPORTED
     * NO无异常 + NOT_SUPPORTED异常
     */
    void noToNotSupported();

    /**
     * 1：NEVER
     * REQUIRED无异常 + NEVER异常
     */
    void requiredToNever();

    /**
     * 2：NEVER
     * REQUIRED无异常 + NEVER异常，REQUIRED捕获NEVER异常
     */
    void requiredToNever1();

    /**
     * 3：NEVER
     * REQUIRED异常 + NEVER无异常
     */
    void requiredToNever2();

    /**
     * 4：NEVER
     * NO无异常 + NEVER异常
     */
    void noToNever();

    /**
     * 1：NESTED
     * REQUIRED无异常 + NESTED异常
     */
    void requiredToNested();

    /**
     * 2：NESTED
     * REQUIRED无异常 + NESTED异常，REQUIRED捕获NESTED异常
     */
    void requiredToNested1();

    /**
     * 3：NESTED
     * REQUIRED异常 + NESTED无异常
     */
    void requiredToNested2();

    /**
     * 4：NESTED
     * NO无异常 + NESTED异常
     */
    void noToNested();

    /**
     * 1：NO
     * REQUIRED无异常 + NO异常
     */
    void requiredToNo();

    /**
     * 2：NO
     * REQUIRED无异常 + NO异常，REQUIRED捕获NO异常
     */
    void requiredToNo1();

    /**
     * 3：NO
     * REQUIRED异常 + NO无异常
     */
    void requiredToNo2();

    /**
     * 4：NO
     * NO无异常 + NO异常
     */
    void noToNo();

    // 加入事务和嵌套事务的区别

    void requiredToRequired3();

    void requiredToRequiresNew3();

    void requiredToNested3();
}
